// sgu332
// 题意：
// 给定一个凸n(<=10000)多边形，求内切圆的最大半径。
//
// 题解：
// 二分半径r，然后将所有凸多边形边长构成的直线沿着一个方向的单位法向量
// 移动r单位距离，然后求半平面交，如果有解就可以继续扩大r，否则缩小。
//
// run: $exec < input
#include <iostream>
#include <vector>
#include <algorithm>
#include <iomanip>
#include <cmath>

double const eps = 1e-8;
struct point
{
    point() {}
    point(double x, double y) : x(x), y(y) {}
    double x, y;
};

point operator-(point const& a, point const& b) { return {a.x - b.x, a.y - b.y}; }
point operator+(point const& a, point const& b) { return {a.x + b.x, a.y + b.y}; }
point operator*(point const& a, double b) { return {a.x * b, a.y * b}; }
point operator/(point const& a, double b) { return {a.x / b, a.y / b}; }
std::istream& operator>>(std::istream& is, point& a) { is >> a.x >> a.y; return is; }

struct line
{
    line() {}
    line(point const& p, point const& v) : p(p), v(v)
    {
        angle = std::atan2(v.y, v.x);
    }

    point p, v;
    double angle;
};

bool operator<(line const& a, line const& b) { return a.angle < b.angle; }

double length(point const& a) { return std::sqrt(a.x * a.x + a.y * a.y); }
point normal(point const& a) { double len = length(a); return {-a.y / len, a.x / len}; }
double cross(point const& a, point const& b) { return a.x * b.y - a.y * b.x; }
bool onleft(line const& l, point const& p) { return cross(l.v, p - l.p) > 0; }

int const maxn = 10007;
point p[maxn], nl[maxn];
line lin[maxn], tlin[maxn];
int n;

template <class T>
T abs(T x) { return x < 0 ? -x : x; }

point get_intersection(line const& a, line const& b)
{
    point u = a.p - b.p;
    double t = cross(b.v, u) / cross(a.v, b.v);
    return a.p + a.v * t;
}

std::vector<point> hp;
std::vector<line> hq;

int half_plane_intersection(line* l, int n)
{
    std::sort(l, l + n);
    int first = 0, last = 0;
    hq[0] = l[0];
    for (int i = 1; i < n; i++) {
        while (first < last && !onleft(l[i], hp[last - 1])) last--;
        while (first < last && !onleft(l[i], hp[first])) first++;
        hq[++last] = l[i];

        if (abs(cross(hq[last].v, hq[last - 1].v)) < eps) {
            last--;
            if (onleft(hq[last], l[i].p)) hq[last] = l[i];
        }
        if (first < last) hp[last - 1] = get_intersection(hq[last - 1], hq[last]);
    }
    while (first < last && !onleft(hq[first], hp[last - 1])) last--;
    if (last - first <= 1) return 0;
    hp[last] = get_intersection(hq[last], hq[first]);
    return last - first + 1;
}

bool judge(double mid)
{
    for (int i = 0; i < n; i++)
        tlin[i] = line(p[i] + nl[i] * mid, p[(i + 1) % n] - p[i]);
    auto count = half_plane_intersection(tlin, n);
    return count > 1;
}

int main()
{
    std::ios::sync_with_stdio(false);
    std::cin >> n;
    hp.resize(n); hq.resize(n);
    for (int i = 0; i < n; i++) std::cin >> p[i];
    for (int i = 0; i < n; i++) {
        lin[i] = line(p[i], p[(i + 1) % n] - p[i]);
        nl[i] = normal(p[(i + 1) % n] - p[i]);
    }
    double l = 0, r = 2e8;
    for (int i = 0; i <= 50; i++) {
        double mid = (l + r) / 2.0;
        if (judge(mid)) l = mid;
        else r = mid;
    }
    std::cout << std::fixed << std::setprecision(5) << l << "\n";
}

